home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Text / WASTE / WASTE 1.1.2 Distribution / Pseudo-UPI for THINK Pascal / Quickdraw.p < prev    next >
Encoding:
Text File  |  1995-10-12  |  10.0 KB  |  327 lines  |  [TEXT/PJMM]
  1. unit Quickdraw;
  2.  
  3. { Pascal Interface to the Macintosh Libraries }
  4.  
  5. { Copyright © Apple Computer Inc. }
  6. { All Rights Reserved }
  7.  
  8. { Adapted for use with THINK Pascal 4.0.x by Marco Piovanelli }
  9.  
  10. interface
  11.     uses
  12.         Types;
  13.  
  14.     type
  15.  
  16.         ConstPatternParam = Pattern;
  17.  
  18.         PatPtr = ^Pattern;
  19.  
  20.         PatHandle = ^PatPtr;
  21.  
  22.     type
  23.  
  24.         DeviceLoopFlags = LONGINT;
  25.  
  26.         BitMapPtr = ^BitMap;
  27.         BitMapHandle = ^BitMapPtr;
  28.  
  29.         QDTextProcPtr = ProcPtr;  { PROCEDURE QDText(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point); }
  30.         QDLineProcPtr = ProcPtr;  { PROCEDURE QDLine(newPt: Point); }
  31.         QDRectProcPtr = ProcPtr;  { PROCEDURE QDRect(verb: ByteParameter; VAR r: Rect); }
  32.         QDRRectProcPtr = ProcPtr;  { PROCEDURE QDRRect(verb: ByteParameter; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER); }
  33.         QDOvalProcPtr = ProcPtr;  { PROCEDURE QDOval(verb: ByteParameter; VAR r: Rect); }
  34.         QDArcProcPtr = ProcPtr;  { PROCEDURE QDArc(verb: ByteParameter; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER); }
  35.         QDPolyProcPtr = ProcPtr;  { PROCEDURE QDPoly(verb: ByteParameter; poly: PolyHandle); }
  36.         QDRgnProcPtr = ProcPtr;  { PROCEDURE QDRgn(verb: ByteParameter; rgn: RgnHandle); }
  37.         QDBitsProcPtr = ProcPtr;  { PROCEDURE QDBits(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle); }
  38.         QDCommentProcPtr = ProcPtr;  { PROCEDURE QDComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle); }
  39.         QDTxMeasProcPtr = ProcPtr;  { FUNCTION QDTxMeas(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo): INTEGER; }
  40.         QDGetPicProcPtr = ProcPtr;  { PROCEDURE QDGetPic(dataPtr: Ptr; byteCount: INTEGER); }
  41.         QDPutPicProcPtr = ProcPtr;  { PROCEDURE QDPutPic(dataPtr: Ptr; byteCount: INTEGER); }
  42.         QDOpcodeProcPtr = ProcPtr;  { PROCEDURE QDOpcode(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER); }
  43.         QDJShieldCursorProcPtr = ProcPtr;  { PROCEDURE QDJShieldCursor(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER); }
  44.         QDTextUPP = UniversalProcPtr;
  45.         QDLineUPP = UniversalProcPtr;
  46.         QDRectUPP = UniversalProcPtr;
  47.         QDRRectUPP = UniversalProcPtr;
  48.         QDOvalUPP = UniversalProcPtr;
  49.         QDArcUPP = UniversalProcPtr;
  50.         QDPolyUPP = UniversalProcPtr;
  51.         QDRgnUPP = UniversalProcPtr;
  52.         QDBitsUPP = UniversalProcPtr;
  53.         QDCommentUPP = UniversalProcPtr;
  54.         QDTxMeasUPP = UniversalProcPtr;
  55.         QDGetPicUPP = UniversalProcPtr;
  56.         QDPutPicUPP = UniversalProcPtr;
  57.         QDOpcodeUPP = UniversalProcPtr;
  58.         QDJShieldCursorUPP = UniversalProcPtr;
  59.  
  60.     const
  61.         uppQDTextProcInfo = $00003F80; { PROCEDURE (2 byte param, 4 byte param, 4 byte param, 4 byte param); }
  62.         uppQDLineProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  63.         uppQDRectProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  64.         uppQDRRectProcInfo = $00002B40; { PROCEDURE (1 byte param, 4 byte param, 2 byte param, 2 byte param); }
  65.         uppQDOvalProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  66.         uppQDArcProcInfo = $00002B40; { PROCEDURE (1 byte param, 4 byte param, 2 byte param, 2 byte param); }
  67.         uppQDPolyProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  68.         uppQDRgnProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  69.         uppQDBitsProcInfo = $0000EFC0; { PROCEDURE (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param); }
  70.         uppQDCommentProcInfo = $00000E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param); }
  71.         uppQDTxMeasProcInfo = $0000FFA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  72.         uppQDGetPicProcInfo = $000002C0; { PROCEDURE (4 byte param, 2 byte param); }
  73.         uppQDPutPicProcInfo = $000002C0; { PROCEDURE (4 byte param, 2 byte param); }
  74.         uppQDOpcodeProcInfo = $00002BC0; { PROCEDURE (4 byte param, 4 byte param, 2 byte param, 2 byte param); }
  75.         uppQDJShieldCursorProcInfo = $00002A80; { PROCEDURE (2 byte param, 2 byte param, 2 byte param, 2 byte param); }
  76.  
  77.     function NewQDTextProc (userRoutine: QDTextProcPtr): QDTextUPP;
  78.     inline
  79.         $2E9F;
  80.  
  81.     function NewQDLineProc (userRoutine: QDLineProcPtr): QDLineUPP;
  82.     inline
  83.         $2E9F;
  84.  
  85.     function NewQDRectProc (userRoutine: QDRectProcPtr): QDRectUPP;
  86.     inline
  87.         $2E9F;
  88.  
  89.     function NewQDRRectProc (userRoutine: QDRRectProcPtr): QDRRectUPP;
  90.     inline
  91.         $2E9F;
  92.  
  93.     function NewQDOvalProc (userRoutine: QDOvalProcPtr): QDOvalUPP;
  94.     inline
  95.         $2E9F;
  96.  
  97.     function NewQDArcProc (userRoutine: QDArcProcPtr): QDArcUPP;
  98.     inline
  99.         $2E9F;
  100.  
  101.     function NewQDPolyProc (userRoutine: QDPolyProcPtr): QDPolyUPP;
  102.     inline
  103.         $2E9F;
  104.  
  105.     function NewQDRgnProc (userRoutine: QDRgnProcPtr): QDRgnUPP;
  106.     inline
  107.         $2E9F;
  108.  
  109.     function NewQDBitsProc (userRoutine: QDBitsProcPtr): QDBitsUPP;
  110.     inline
  111.         $2E9F;
  112.  
  113.     function NewQDCommentProc (userRoutine: QDCommentProcPtr): QDCommentUPP;
  114.     inline
  115.         $2E9F;
  116.  
  117.     function NewQDTxMeasProc (userRoutine: QDTxMeasProcPtr): QDTxMeasUPP;
  118.     inline
  119.         $2E9F;
  120.  
  121.     function NewQDGetPicProc (userRoutine: QDGetPicProcPtr): QDGetPicUPP;
  122.     inline
  123.         $2E9F;
  124.  
  125.     function NewQDPutPicProc (userRoutine: QDPutPicProcPtr): QDPutPicUPP;
  126.     inline
  127.         $2E9F;
  128.  
  129.     function NewQDOpcodeProc (userRoutine: QDOpcodeProcPtr): QDOpcodeUPP;
  130.     inline
  131.         $2E9F;
  132.  
  133.     function NewQDJShieldCursorProc (userRoutine: QDJShieldCursorProcPtr): QDJShieldCursorUPP;
  134.     inline
  135.         $2E9F;
  136.  
  137.     procedure CallQDTextProc (byteCount: INTEGER;
  138.                                     textBuf: Ptr;
  139.                                     numer: Point;
  140.                                     denom: Point;
  141.                                     userRoutine: QDTextUPP);
  142.     inline
  143.         $205F, $4E90;
  144.  
  145.     procedure CallQDLineProc (newPt: Point;
  146.                                     userRoutine: QDLineUPP);
  147.     inline
  148.         $205F, $4E90;
  149.  
  150.     procedure CallQDRectProc (verb: ByteParameter;
  151.                                     var r: Rect;
  152.                                     userRoutine: QDRectUPP);
  153.     inline
  154.         $205F, $4E90;
  155.  
  156.     procedure CallQDRRectProc (verb: ByteParameter;
  157.                                     var r: Rect;
  158.                                     ovalWidth: INTEGER;
  159.                                     ovalHeight: INTEGER;
  160.                                     userRoutine: QDRRectUPP);
  161.     inline
  162.         $205F, $4E90;
  163.  
  164.     procedure CallQDOvalProc (verb: ByteParameter;
  165.                                     var r: Rect;
  166.                                     userRoutine: QDOvalUPP);
  167.     inline
  168.         $205F, $4E90;
  169.  
  170.     procedure CallQDArcProc (verb: ByteParameter;
  171.                                     var r: Rect;
  172.                                     startAngle: INTEGER;
  173.                                     arcAngle: INTEGER;
  174.                                     userRoutine: QDArcUPP);
  175.     inline
  176.         $205F, $4E90;
  177.  
  178.     procedure CallQDPolyProc (verb: ByteParameter;
  179.                                     poly: PolyHandle;
  180.                                     userRoutine: QDPolyUPP);
  181.     inline
  182.         $205F, $4E90;
  183.  
  184.     procedure CallQDRgnProc (verb: ByteParameter;
  185.                                     rgn: RgnHandle;
  186.                                     userRoutine: QDRgnUPP);
  187.     inline
  188.         $205F, $4E90;
  189.  
  190.     procedure CallQDBitsProc (var srcBits: BitMap;
  191.                                     var srcRect: Rect;
  192.                                     var dstRect: Rect;
  193.                                     mode: INTEGER;
  194.                                     maskRgn: RgnHandle;
  195.                                     userRoutine: QDBitsUPP);
  196.     inline
  197.         $205F, $4E90;
  198.  
  199.     procedure CallQDCommentProc (kind: INTEGER;
  200.                                     dataSize: INTEGER;
  201.                                     dataHandle: Handle;
  202.                                     userRoutine: QDCommentUPP);
  203.     inline
  204.         $205F, $4E90;
  205.  
  206.     function CallQDTxMeasProc (byteCount: INTEGER;
  207.                                     textAddr: Ptr;
  208.                                     var numer: Point;
  209.                                     var denom: Point;
  210.                                     var info: FontInfo;
  211.                                     userRoutine: QDTxMeasUPP): INTEGER;
  212.     inline
  213.         $205F, $4E90;
  214.  
  215.     procedure CallQDGetPicProc (dataPtr: Ptr;
  216.                                     byteCount: INTEGER;
  217.                                     userRoutine: QDGetPicUPP);
  218.     inline
  219.         $205F, $4E90;
  220.  
  221.     procedure CallQDPutPicProc (dataPtr: Ptr;
  222.                                     byteCount: INTEGER;
  223.                                     userRoutine: QDPutPicUPP);
  224.     inline
  225.         $205F, $4E90;
  226.  
  227.     procedure CallQDOpcodeProc (var fromRect: Rect;
  228.                                     var toRect: Rect;
  229.                                     opcode: INTEGER;
  230.                                     version: INTEGER;
  231.                                     userRoutine: QDOpcodeUPP);
  232.     inline
  233.         $205F, $4E90;
  234.  
  235.     procedure CallQDJShieldCursorProc (left: INTEGER;
  236.                                     top: INTEGER;
  237.                                     right: INTEGER;
  238.                                     bottom: INTEGER;
  239.                                     userRoutine: QDJShieldCursorUPP);
  240.     inline
  241.         $205F, $4E90;
  242.  
  243.     type
  244.  
  245.         RGBColorPtr = ^RGBColor;
  246.         RGBColorHdl = ^RGBColorPtr;
  247.  
  248.         DragGrayRgnProcPtr = ProcPtr;  { PROCEDURE DragGrayRgn; }
  249.         ColorSearchProcPtr = ProcPtr;  { FUNCTION ColorSearch(VAR rgb: RGBColor; VAR position: LONGINT): BOOLEAN; }
  250.         ColorComplementProcPtr = ProcPtr;  { FUNCTION ColorComplement(VAR rgb: RGBColor): BOOLEAN; }
  251.         DragGrayRgnUPP = UniversalProcPtr;
  252.         ColorSearchUPP = UniversalProcPtr;
  253.         ColorComplementUPP = UniversalProcPtr;
  254.  
  255.     const
  256.         uppDragGrayRgnProcInfo = $00000000; { PROCEDURE ; }
  257.         uppColorSearchProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }
  258.         uppColorComplementProcInfo = $000000D0; { FUNCTION (4 byte param): 1 byte result; }
  259.  
  260.     function NewDragGrayRgnProc (userRoutine: DragGrayRgnProcPtr): DragGrayRgnUPP;
  261.     inline
  262.         $2E9F;
  263.  
  264.     function NewColorSearchProc (userRoutine: ColorSearchProcPtr): ColorSearchUPP;
  265.     inline
  266.         $2E9F;
  267.  
  268.     function NewColorComplementProc (userRoutine: ColorComplementProcPtr): ColorComplementUPP;
  269.     inline
  270.         $2E9F;
  271.  
  272.     procedure CallDragGrayRgnProc (userRoutine: DragGrayRgnUPP);
  273.     inline
  274.         $205F, $4E90;
  275.  
  276.     function CallColorSearchProc (var rgb: RGBColor;
  277.                                     var position: LONGINT;
  278.                                     userRoutine: ColorSearchUPP): BOOLEAN;
  279.     inline
  280.         $205F, $4E90;
  281.  
  282.     function CallColorComplementProc (var rgb: RGBColor;
  283.                                     userRoutine: ColorComplementUPP): BOOLEAN;
  284.     inline
  285.         $205F, $4E90;
  286.  
  287.     type
  288.         DeviceLoopDrawingProcPtr = ProcPtr;  { PROCEDURE DeviceLoopDrawing(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT); }
  289.         DeviceLoopDrawingUPP = UniversalProcPtr;
  290.  
  291.     const
  292.         uppDeviceLoopDrawingProcInfo = $00003E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param, 4 byte param); }
  293.  
  294.     function NewDeviceLoopDrawingProc (userRoutine: DeviceLoopDrawingProcPtr): DeviceLoopDrawingUPP;
  295.     inline
  296.         $2E9F;
  297.  
  298.     procedure CallDeviceLoopDrawingProc (depth: INTEGER;
  299.                                     deviceFlags: INTEGER;
  300.                                     targetDevice: GDHandle;
  301.                                     userData: LONGINT;
  302.                                     userRoutine: DeviceLoopDrawingUPP);
  303.     inline
  304.         $205F, $4E90;
  305.  
  306.     type
  307.         QDGlobals = record
  308.                 privates: packed array[0..75] of CHAR;
  309.                 randSeed: LONGINT;
  310.                 screenBits: BitMap;
  311.                 arrow: Cursor;
  312.                 dkGray: Pattern;
  313.                 ltGray: Pattern;
  314.                 gray: Pattern;
  315.                 black: Pattern;
  316.                 white: Pattern;
  317.                 thePort: GrafPtr;
  318.             end;  { QDGlobals }
  319.  
  320. { To be in sync with the C interface to QuickDraw globals, pascal code must now }
  321. { qualify the QuickDraw globals with “qd.” (e.g. InitGraf(@qd.thePort);  )       }
  322.  
  323. { Yeah, right. }
  324. { Unfortunately, the THINK Pascal Interface.Lib file does not define "qd" for us. :-( }
  325.  
  326. implementation
  327. end.